Automated Translation of High Order Complex Geometry from a Cad Model into a Surface Based Combinatorial Geometry Format

ABSTRACT

The descriptions of higher order complex geometry in CAD systems are fundamentally different from and seemingly incompatible with the surface based combinatorial geometry (SBCG) format for describing the same geometry in the context of general ray-tracing applications such as radiation transport. A computer implemented process translates the high order complex geometry embodied in CAD software to the SBCG format. The translation process is comprised of a set of lower-level algorithms that operate on two data sets which are commonly available from commercial CAD software systems. The first data set is a list of trimmed surfaces which make up a given part. These data are typically available from one of the standard geometry representations such as IGES, STEP, or ACIS, at least one of which is supported by each of the major CAD systems (e.g. ProEngineer). The second data set is nodal data: an appropriately dense grouping of point coordinates, designated as either inside or outside the part. These data may be obtained by discretizing solid geometry both within and external to the part of interest using standard FE tools (e.g. ProMechanica). The process translates these two data sets into a list of analytic surfaces and a well-posed zoning statement and then optimizes that statement.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation and claims benefit under 35 U.S.C.120 of currently pending U.S. patent application Ser. No. 10/838,411entitled “Automated Translation of High Order Complex Geometry from aCad Model into a Surface Based Combinatorial Geometry Format” filed May4, 2004, which claims benefit of priority under 35 U.S.C. 119(e) to U.S.Provisional Application No. 60/471,580 entitled “Computerized ModelingSystem and Method to Transform Nodal and Parametric Surface Data fromCAD Product Form into Efficient, High Accuracy, Combinatorial Geometry”filed on May 19, 2003, the entire contents of which are incorporated byreference.

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates to computer implemented techniques fortranslating high order complex geometry from the computer aided design(CAD) model to a surface based combinatorial geometry (SBCG) format suchas commonly used in nuclear radiation transport, optical design, thermalradiation transport, visual scene rendering or other general ray-tracingapplications.

2. Description of the Related Art

The development of geometrical descriptions of hardware in CAD systemsis fundamentally different from the concerns in describing the samegeometry in the context of radiation transport and other ray-tracingapplications. Typically, CAD systems are intended to make it easy tobuild up and modify complex assemblies based on the design intent of themechanism. Radiation transport codes, on the other hand, are solelyconcerned with the motion of energetic particles through matter; neitherthe design intent nor the mechanical purpose of a part has anysignificance in this context. To analyze the effects of radiation onsystems that were designed using CAD software, those designs must betranslated from their native form into a form that is compatible withthe requirements of standard radiation transport tools.

While the details of specific commercial CAD geometry data structuresare typically proprietary (aside from the standard output formats suchas IGES, ACIS and STEP), it is sufficiently illustrative to considerConstructive Solid Geometry (CSG) as a means of building up complicatedparts and assemblies from simple geometrical constructs. In CSG, partsare typically designed by performing simple operations such astranslation, rotation and scaling on finite primitive solids such asspheres, cylinders, and boxes. Furthermore, objects can be modified incombination by the use of Boolean operators. The set of Booleanoperations includes taking the union or intersections of two sets ofobjects, as well as subtracting the space associated with one set ofobjects from the solid material associated with another. A simple part10 comprising a slot 12 having rounded ends 14 formed in a base 16 isshown in FIGS. 1 a and 1 b. In a CSG framework, this object might becreated by instantiating a box that makes up the base of the partcreating two cylinders that comprise the rounded ends of the slot, andnext creating a box that joins the two cylinders. Boolean operations canthen be performed to join the cylinders with their aligned box, andsubtract that union from the original base, leaving the part asdepicted. In this framework, very few operations are required todescribe rather complicated geometrical shapes. This ability to usesuccessive sets of simple operations to build very complex shapes israther evocative of the machining process. In fact, the CSG method grewout of generations of 3-D CAD systems that began with the set ofprimitives familiar to 2-D draftsmen, namely line segments and curves.

Unlike CAD geometry, the dominant paradigm for radiation transportgeometry has remained largely unchanged for the last three decades. Whenthe first formulations of the major radiation transport codes wereoriginally proposed by physicists at the national laboratories,minimizing the fraction of the computation cycles devoted to geometryprocessing was crucial. The computers at the time were capable only oftens of floating-point operations per second, so processing nuclearreaction computations in statistically significant numbers requiredextremely streamlined geometry calculations.

The solutions that physicists at Lawrence Livermore National Laboratory(LLNL), and Los Alamos National Laboratory (LANL) derived to format datafor use in radiation transport codes were, not coincidentally,conceptually the same. The TART (LLNL) and MCNP (LANL) codes useunbounded analytical surfaces to simply bound regions in space. Bothcodes have input decks that list all the analytical surface definitions,each with a unique index for identification purposes, and further listeach unique region of space as a simple sub-list of the surface indiceswhich comprise the boundaries of the region. These surface indices aresigned positive or negative based on an arbitrary convention for whetherthe region (commonly referred to as a cell or zone) of interest lies onthe interior or exterior of the analytic surface.

Analytic surfaces have the unique property that a simple closed formequation will yield the surface's points of intersection with anarbitrarily placed vector. Consequently, if the geometry is initiallydefined by analytic surfaces, the need for any subsequent computationsto recover analytic form can be eliminated. Furthermore, having thezones defined in terms of only the signed bounding surfaces minimizesthe necessary computations to determine when a particle might leave azone along any particular trajectory. So the geometry paradigm inradiation transport codes consists of unbounded analytic surfacesknitted together by zone definitions in simple intersection logic (e.g.a well-posed zoning statement). This is referred to as surface-basedcombinatorial geometry (SBCG). The analytic surface libraries vary fromcode to code, but typically include, at a minimum, spheres, cylinders,planes, and cones. The definition of such surfaces includes informationto translate, rotate and scale them in space.

Current practice to translate the high order complex geometry from thecomputer aided design (CAD) model to the SBCG format is laborious, timeconsuming and error prone. Quite literally engineers are provided withCAD drawings of the complex parts and use a ruler and protractor todetermine the equations for the analytic surfaces that make up eachpart. Subsequently, they determine the zoning statement usinghand-drawing sketches and trial and error methodology. Returning to theexample part, the list of analytic surfaces 20 includes both boundingsurfaces 22 (S1-S8) and ambiguity surfaces 24 (S9-S10) which can be usedto define zones Z1, Z2, Z3 and Z4 as shown in FIG. 2 a for part 10 via awell-posed zoning statement 26 as shown in FIG. 2 b required for theSBCG format. This process takes many hours for each part and is prone tohuman error. A single error can create an ill-posed zoning statement,hence an invalid translation. The complexity of manual translationincreases dramatically with complex 3-D parts.

There exists an acute need for a computer implemented process fortranslating high order complex geometry from the CAD format it wascreated in to a SBCG format. Such an automated translation would beuseful not only in nuclear radiation transport applications but alsooptical design, stray light analysis, thermal radiation transport,visual scene rendering and other general ray-tracing applications.

SUMMARY OF THE INVENTION

The present invention provides for the automated translation of highorder complex geometry from a CAD model into a surface basedcombinatorial geometry (SBCG) format for use in nuclear radiationtransport, optical design, stray light analysis, thermal radiationtransport, visual scene rendering and other general ray-tracingapplications.

Automated translation is accomplished by extracting the required trimmedsurfaces and nodal data from the CAD software and tools, translatingthat data into a list of analytic surfaces, formulating a well-posedzoning statement, and optimizing that zoning statement. Morespecifically, the computer calculates analytic bounding surfaces fromthe list of trimmed surfaces, forms any required analytic ambiguitysurfaces, generates lists of part and void space nodes from the nodaldata and compares each node to each of the analytic surfaces toformulate the initial zoning statement. The computer may then optimizethe zoning statement by eliminating references to redundant surfaces andby merging zones using, for example, a binary minimization algorithm.

In an exemplary embodiment, the CAD software provides a file thatincludes information about the geometric entities that comprise thepart. The computer examines each entity to determine the type ofgeometric object and maps any surface-type entity to an analyticbounding surface with the proper translation. The computer then performsa comparison of each bounding surface to every other bounding surface todetermine if any of a list of conditions is met. If a particularcondition is true, the computer generates an analytic ambiguity surfaceneeded for differentiating zones at the intersection of the two boundingsurfaces.

The CAD software or associated tool (finite element or random nodegeneration) provides two lists of candidate nodes, one covering the partand the other covering any void spaces. Various techniques are used toensure that the node lists are sufficiently populated such that even thesmallest features of the part are appropriately characterized by nodeswithin and without.

Armed with this list of analytic bounding and ambiguity surfaces andlists of nodal data, the next step in this exemplary embodiment is toformulate an initial zoning statement by comparing each node to each ofthe analytic surfaces, designating whether the node lies “inside” or“outside” each of the analytic surfaces with a list of signed numbers(“nodal zoning statement”), and comparing the list to other existinglists corresponding to other nodes. If there is a match, the computerassigns the node the label of the existing identical list. If not, thecomputer assigns the node a new label. A complete table of these listsof the relationship between nodes and each surface in the geometrycomprise the initial zoning statement.

Finally, the initial zoning statement is optimized using a binaryminimization algorithm in which these tabular relationship lists areiteratively subdivided into successively smaller sub-tables, until a setof minimally-sized sub-tables is achieved. At this point each sub-tablecan be solved using a genetic algorithm. This information can bepropagated by regressing back through the decomposition process, andrepeating the solution procedure with each reunited sub-table until theentire geometry of the part has been reunited.

These and other features and advantages of the invention will beapparent to those skilled in the art from the following detaileddescription of preferred embodiments, taken together with theaccompanying drawings, in which:

BRIEF DESCRIPTION OF THE DRAWINGS

FIGS. 1 a and 1 b, as described above, are isometric and plan views of asimple 2-D part;

FIGS. 2 a and 2 b, as described above, are a plan view of the 2-D partwith the bounding surfaces and ambiguity surfaces highlighted, and atypical zoning statement for that geometry;

FIG. 3 is a flowchart of an automated process for translating high ordercomplex geometry from a CAD model to a surface based combinatorialgeometry (SBCG) format in accordance with the present invention;

FIG. 4 a is a plan view of the 2-D part with the trimmed surfacesgenerated by the CAD program and FIGS. 4 b and 4 c are plan views of thenodal mesh generated by a FE program for the 2-D part and the voidspace, respectively;

FIG. 5 is a plan view of the 2-D part illustrating the analytic boundingand ambiguity surfaces;

FIGS. 6 a through 6 f are detailed flowcharts for extracting analyticbounding surfaces from the construction data in IGES files;

FIGS. 7 a and 7 b are tables of rules for generating ambiguity surfaces;

FIGS. 8 a through 8 c illustrate the steps for formulating an initialzoning statement;

FIGS. 9 a through 9 d illustrate the steps for optimizing the initialzoning statement using a particular binary minimization algorithm; and

FIG. 10 is a detailed flowchart of one embodiment of the automatedtranslation process.

DETAILED DESCRIPTION OF THE INVENTION

This invention provides an automated computer-implemented process fortranslating the CAD model for a part's high order complex geometry intoa surface based combinatorial geometry (SBCG) format for use in nuclearradiation transport, optical design, stray light analysis, thermalradiation transport, visual scene rendering and other generalray-tracing applications. Automated translation involves the steps ofextracting the required trimmed surfaces and nodal data from the CADmodel, translating that data into a list of analytic surfaces andformulating a well-posed zoning statement, and finally optimizing thatzoning statement.

As shown in FIG. 3, the high order complex geometry for a part istranslated from a CAD Model 30 into a SBCG format 32 using an automatedprocess implemented on a computer 34, which improves speed, accuracy andconsistency of the translation. The first step in developing theautomated process was to realize that the data required for such anautomated translation was readily supported by all major CAD programssuch as ProEngineer and finite element (FE) tools such as Pro Mechanicaor ANSYS commonly used in conjunction with CAD programs. Morespecifically, the CAD programs write a list of trimmed surfaces (step36) as a normal output of forming the three-dimensional CAD models. TheCAD program, e.g. a FE tool or a random node generation algorithm,writes a list of nodes for the part and a list for any void spaces (step38).

The second step was to develop the computer-implemented process fortranslating the list of trimmed surfaces into a list of analyticsurfaces and then using those surfaces and nodal data derived from thecandidate nodes to formulate a well-posed zoning statement (step 40).The automated translation and formulation is a four step process inwhich the computer calculates the analytic equations for boundingsurfaces from the list of trimmed surfaces (step 42), forms any requiredambiguity surfaces (step 44), refines the lists of part and void spacenodes to eliminate any nodes that lie too close to boundary surfaces andto add nodes to ensure sufficient density (step 46) and compares eachnode to each of the analytic surfaces to form a nodal zoning statementfor each unique region of space (“zone”) (step 48). The list of nodalzoning statements forms the initial well-posed zoning statement. Theautomated steps for generating the bounding surfaces (“IGESread”),ambiguity surfaces (“Ambisurf”), and initial zoning statement(“Midnode”) are detailed in FIGS. 6 a-6 f, 7 a-7 b and 8 a-8 c,respectively. Once the computer has translated the CAD model into a SBCGformat it is generally desirable, although not necessary, to optimizethe zoning statement by merging zones and eliminating references toredundant surfaces to improve translation efficiency using, for example,a binary minimization algorithm (step 50). A binary minimizationalgorithm that recursively bisects the zoning statement into smaller andsmaller problems and then solves the sub-problems using a geneticalgorithm is detailed in FIGS. 9 a-9 d (“Break”, “Zoner” and “Rebuild”).An example of one instantiation of the automated computer-implementedprocess is given in FIG. 10.

The application of the algorithm to the simple slotted part 10 isillustrated in FIGS. 4, 5 and 8 c. The CAD program writes a list trimmedsurfaces 52 S1, S2, . . . S8 for the slotted part 10. Surfaces S1, S2,S3 and S4 bound the base 16, surfaces S5 and S6 bound the sides of slot12, and surfaces S7 and S8 bound the rounded ends 14. The spaces insideslot 12 and outside base 16 define void spaces 54. A FE tool, forexample, generates meshes 56 and 58 for the part and any void spaces,respectively. The lists of all of the vertices of each mesh form a pairof lists of candidate nodes 60 and 61 for the part and void spaces. Thenodes that are internal to the part or void space are indicated with aclosed bullet whereas the nodes that lie on bounding surfaces areindicated with an open bullet. The computer generates a list of analyticsurfaces 62 by calculating bounding surfaces 63 U1, U2, U3 and U4 thatbound the base 16, surfaces U5 and U6 that bound the sides of slot 12,and surfaces U7 and U8 that bound the rounded ends 14, and formingambiguity surfaces 64 A1 and A2 where the bounding surfaces are notsufficient to determine whether a node lies in the part or the voidspace. The computer then refines the lists of nodes 60 and 61 to removeany ambiguous nodes. The first list 60 includes the “closed-bullet”nodes 65 that lie on the part. The second list 61 includes the“closed-bullet” nodes 65 that lie in the void spaces. The “open-bullet”nodes 66 lying on or too near bounding surfaces are discarded. Thecomputer compares each node to each analytic surface to generate asequence of nodal zoning statements 67 as shown in FIG. 8 c. The tableof nodal zoning statements 67 forms an initial zoning statement 68. Thecomputer may then optimize the zoning statement to produce, for example,the same zoning statement 26 shown in FIG. 2 b generated using thelaborious manual process. For clarity of presentation, this exampleconsidered only the 2D projection of the slotted part. However, all ofthe principles and techniques are extensible to the more general 3Drepresentation and to more complicated parts.

Calculate Bounding Surfaces

The task of calculating the bounding surfaces 63 in FIG. 5 from thetrimmed surfaces 52 in FIG. 4 is non-trivial. The IGES file structurefor the list of trimmed surfaces includes among other things a pluralityof entities (trimmed surfaces, line segments, closed curves, coordinatetransformations, etc.). Each such entity is characterized by a typenumber that specifies what sort of geometrical object the entity is anda pointer to the parametric information that specifies the specific datathat defines the entity. Additionally, many entity types will alsoreference a transformation matrix that describes any rotation,translation or scaling of the entity. The computer-implemented processexamines each entity to determine whether it is a b-spline surface,torus or sphere, revolved plane, cylinder or revolved cone. As eachentity is identified, the trimmed surface is mapped to the correspondinganalytic surface with the proper transformation (rotation, translationor scaling) and stored as an entry in the list of analytic surfaces 62.

The IGES (Initial Graphics Exchange Specification) standard is one ofthe typical geometric representations supported by the major CADsystems. FIGS. 6 a through 6 f illustrate one possible approach (a codereferred to as IGESread) for calculating the bounding surfaces directlyfrom IGES files. The version of IGESread discussed herein was writtenspecifically for use with IGES files written by ProEngineer; however itmay be adapted to do the same for IGES files created by other CADprograms. Furthermore, a similar routine could be created to extractdata from STEP or ACIS files. Planned extensions of this code will usethe same basic techniques already in place to expand the list ofapplicable surface types, eventually covering the entire library ofanalytic surfaces in TART and MCNP.

The IGES file specification is a NIST-supported standard that dates from1979; it is by far the oldest and most widely used mechanism forexchange of model data between CAD products. The IGES file structureconsists of five main sections: title, header, entity data, parameterdata, and a termination line. The significant portions of the file arethe entity and parameter data; the entity section consists of integerand text data that specifies the existence of each node, line, andsurface of the construct. Amongst the integers in the entity data is atype number which specifies what sort of geometrical object the entityis, a pointer to a transformation matrix that describes any rotation,translation, or scaling of the entity in space, and a pointer to thefirst line of parameter data that applies to that specific entity. Theparameter data consists of integer and real number data that define thespecific features of the entity of interest. Parameters may also includepointers to other entities that help to specify the object.

IGESread's topmost level is depicted in FIG. 6 a. IGESread begins byopening the user-specified IGES files containing the desired geometry(step 70). The code skips the title and header data (step 72), thenreads and stores the entity and parameter data in convenient datastructures (steps 74, 76). The algorithm then examines each entity inturn (step 78), determining if the entity is a first order b-splinesurface, and if so calling the subroutine Bscalc, which itself isdepicted in FIG. 6 b. Next the code takes another pass through the data(step 80), this time looking for revolved surfaces—that is, surfacescreated by revolving a specified curved or straight line (thegeneratrix) around a specified axis. During this pass, the algorithmstores data for straight line generatrices (steps 82, 84), and processesgeneratrices that are arcs (steps 86,88). Arc generatrices form spheresor toroids when revolved; an exemplary process of reconstructing thosesurfaces is depicted in FIG. 6 c. If the revolved surface is neither anarc nor a line it is skipped (step 90). When this pass is complete (step92), a pass through the list of revolved line segments is made (step94). Each generatrix is checked in turn to determine whether it is in acommon plane with the axis; if not, the lines are skew (step 96), andthe revolving procedure will produce a non-standard surface type, so theentity is skipped (step 98). Next the line segments are tested forperpendicularity (step 100); if they are perpendicular, the generatrixdefines a plane (step 102), so the plane equations are computed andstored as described in FIG. 6 d. If neither perpendicular nor skew, thelines are tested for parallelism (step 104), in which case a cylinder isformed (step 106). FIG. 6 e shows the flow for the cylinder extractioncode. Finally, any straight-line generatrix that is neitherperpendicular, nor parallel, nor skew to the axis will define a conewhen revolved (step 108); this portion of the algorithm is depicted inFIG. 6 f. Each of the major steps is discussed in greater detail in thefollowing paragraphs. The process iterates until the revolved lines areexhausted (step 110).

First Order B-spline Surfaces

As mentioned above, the Bscalc subroutine shown in FIG. 6 b is called onfirst-order b-spline surfaces. This subroutine moves the parameter datafrom the first order b-spline surface entity into a convenient datastructure (step 112). The algorithm performs a series of checks todetermine that the data actually conforms to the expected arrangementfor a first order b-spline, namely that it has the correct number ofparameters (step 114), that there is no transformation card (step 116),and that all the weight factors are equal to 1.0 (step 118). If any ofthese things are not true, the algorithm throws an error and continueswith the next entity (step 120). If this series of tests is passed, thealgorithm identifies the control point data for each of four nodes (step122). Next the algorithm forms three vectors from the first node to eachof the other three (step 124). The algorithm computes the cross productof the first two vectors and the magnitude of that vector product (step126). With this information, the algorithm completes two more tests todemonstrate that the plane is mathematically well formed; it tests tosee that all four nodes are not collinear (step 128), and that all fourpoints are coplanar (step 130). If either of these conditions is notmet, an error is thrown (step 120), and the algorithm continues with thesubsequent entity. The equations for the plane are computed (step 132).If the plane is not already defined (step 134), the subroutine storesthe equations for the plane (step 136) and ends (step 138), returningcontrol back to the main body of the code.

Toroids and Spheres

The algorithm for extracting a toroid or spherical surface formed by therevolution of a circular arc about an axis is depicted in FIG. 6 c. Thisextraction begins by storing the point data that defines the axis ofrevolution for the entity (a1 & a2) (step 140). The arc data (thegeneratrix) is stored as three points under transformation: the centerof the arc and the endpoints of the arc (step 142). Because the desiredanalytic surface definitions are all unbounded, only the center and oneendpoint are required to be specified in the algorithm (g′1 & g′2).Next, the transformation matrix associated with the arc is extracted(step 144), and applied to the g′ points, so that the real spatiallocation of the arc is computed (g1 & g2) (step 146). Next, the vectorforming the axis is computed (step 148) and its magnitude is evaluated(step 150). Using this information, the algorithm computes a parameter T(step 151) and then computes the distance from the center of the arc tothe axis, which is the major radius, r2 (step 152). The algorithm thenforms a vector from g1 to g2 (step 154) (see insert), and computes itslength, the minor axis r1 (step 156). The value of r2 constitutes theinformation necessary to distinguish a torus from a sphere. If the majorradius is equal to zero (step 158) (this is actually implemented asbeing smaller than an arbitrarily small tolerance value), then theconstruct is a sphere, (step 160) and all the data necessary to describeit have been calculated. The center is at the point g1, the radius isr1. The algorithm checks to make sure that the entity being extracted isnovel by comparing it to every previously defined sphere (step 162), andit stores the data only if it is new (step 164). When r2 is greater thanzero, the entity is a toroid (step 166). In that case it is necessary tocompute the location of the point on the axis of rotation nearest g1(steps 168, 170), and the azimuth and elevation angles of the axis (step172). This computation proceeds as follows:

The axis is parameterized via:x=x1+t×(x1−x2) y=y1+t×(y1−y2) z=z1+t×(z1−z2) where a1=(x1,y1,z1) anda2=(x2,y2,z2)

The square of the distance d from g1=(x3,y3,z3) to any point t on theparameterized line is:d ²=(x3−x1−(x1−x2)t)²+(y3−y1−(y1−y2)t)²+(z3−z1−(z1−z2)t)²

Evaluating ∂(d²)/∂t=0, and solving for t gives the parametercorresponding to the minimum distance.t0=[(x1−x2)(x3−x1)]+[(y1−y2)(y3−y1)]+[(z1−z2)(z3−z1)]and: x0=x1+(x1−x2)t0; y0=y1±(y1-y2)t0; z0=z1+(z1-z2)t0, which are thecoordinates of the center of the toroid. The axis angles are computed asφ=a cos [a(z)/∥a∥] and θ=a tan2[a(y),a(x)]

The algorithm checks to make sure that the entity being extracted isnovel by comparing it to every previously defined torus (step 174),stores the data only if it is new (step 176), and finally the algorithmends, returning control back to the main program (step 178).

Revolved Line Segments—Planes

On the final pass through the identified surfaces consisting of revolvedline segments, IGESread begins by identifying and skipping thosesurfaces created by sweeping a skew line around an axis. Next, thealgorithm identifies when the axis and generatrix are orthogonal to oneanother; when such a line is swept, the resulting surface will be aplane. The algorithm which extracts revolved plane surfaces as shown inFIG. 6 d begins by extracting the point data for the two line segmentsthat compose the axis and generatrix (steps 180, 182). The code thenforms vectors corresponding to the axis and generatrix (steps 184, 186).The dot product of these two vectors is calculated (step 188). If thedot product is not 0 (step 190), the line segments are not orthogonal,and this portion of the code has been reached in error (step 192). Afterperforming this test, the magnitude of the axis vector is calculated(step 194), and the direction cosines of the vector normal to thesurface (which happens to be the axis vector) are calculated (steps 196,198, 200). Finally, the algorithm compares the newly calculated plane toevery previously defined plane to determine if the plane is novel (step202). If the plane hasn't been previously identified, the data storedconsists of the three direction cosines as well as the x, y, zcoordinates of the first point of the generatrix (step 204).

Revolved Line Segments—Cylinders

The next possibility for revolved line segments is that the axis andgeneratrix are parallel; in this case the surface described is acylinder as shown in FIG. 6 e. First the algorithm extracts the pointdata for the two line segments (steps 210, 212), then vectors are formedfor each (steps 214, 216). Next, the magnitude of the axis vector isevaluated (step 218), and the cross product of the axis and generatrixvectors is computed (step 220). If the magnitude of the vector crossproduct computed in (step 222) is not zero (step 224) the lines are notparallel, and so an error is generated (step 226). Next the radius ofthe cylinder is computed using the same technique used to compute thepoint on the axis closest to the center of an arc, which was developedin the toroid generation portion of IGESread (steps 228, 230). In thiscase, once the appropriate parameter is computed, the radius itself iscalculated instead of the near point coordinates. Then the point atwhich the axis intersects the z=0 plane is computed (step 232). This isfound by using the parameterized form for the axis and solving for x andy when z=0. The last cylinder parameters are computed by determining theazimuthal and elevation angles of the axis, exactly as they were for thetoroidal case (step 234). Finally, the cylinder is compared to everyprevious cylinder (step 236), and stored only if it is new (step 238).

Revolved Line Segments—Cones

Finally, IGESread treats revolved line segments that are neither skew,nor orthogonal, nor parallel. This is the family of cones. The flowdiagram in FIG. 6 f makes use of many of the same mathematicalrelationships developed for previously discussed entities. The algorithmbegins by extracting the necessary point data (axis a1=(x1,y1,z1),a2=(x2,y2,z2) (step 240), generatrix g1=(x3,y3,z3), g2=(x4,y4,z4)) (step242), forming vectors for each line segment (steps 244, 245, 246), andtesting the dot and cross products to ensure that the desired surface isa cone (step 248, 250, 252, 254, 256, 258). Next the intersection pointof the axis and generatrix is computed (step 260, 262); this will be thevertex of the cone. This is done by parameterizing the two lines:axis: x=x1±t1×(x2−x1) y=y1±t1×(y2−y1) z=z1+t1×(z2−z1)generatrix: x=x3+t2×(x4−x3) y=y3+t2×(y4−y3) z=z3+t2×(z4−z3)and solving for t1 and t2 such that the full set of equations issimultaneously solved by a single (x, y, z) trio. This of courseproduces 3 equations for two unknowns, and hence is over-specified, butIGESread includes a case structure that will pare down the permutationsand eliminate singularities in the case of line segments parallel to anaxis. Lastly, the azimuthal and elevation angles of the axis arecalculated as outlined previously (step 264), and additionally the anglebetween the axis and generatrix is calculated: since ∥a×g∥=∥a∥ ∥g∥ sinθ, where θ is the angle between the vectors a and g, sinθ=∥a×g∥/∥a∥/∥g∥. The extracted cone data are compared to all previouslyspecified cones (step 266), and stored only if they are determined to beunique (step 268).Generate Ambiguity Surfaces

To complete the list of analytic surfaces 62 the computer-implementedalgorithm must identify and form all of the ambiguity surfaces 64required for a well-posed zoning statement. The ambiguity surfacesinclude those additional surfaces that are necessary to subdivide a partinto zones that are not created from the original trimmed surfacesbecause they are not bounding surfaces. A typical case is shown in FIG.5, where the slot with rounded ends requires an additional plane neareither end 14 to differentiate the various regions of the geometry thatare between the planes S5 and S6, and are outside the two circularsurfaces S7 and S8 (Recall from background discussion that the surfacesimplemented in TART only divide the universe into two pieces, spaceinside and outside the surface, there is no notion of “space to theupper left of this surface.”). These ambiguity surfaces are the planeslabeled A1 and A2 in the figure. The algorithm of Ambisurf is apair-wise comparison of all the surfaces extracted from apart byIGESread. As shown in FIGS. 7 a and 7 b, a library 270 of surface pairs272 has been developed that lists the conditions 274 under which thegeneration of one or more ambiguity surfaces is likely to be necessary.The library also includes formulas for the ambiguity surface 276 neededfor differentiation at the intersection of two surfaces. It is expectedthat this library will grow over time, as experience is gained inrendering complex models using the tools described herein.

Generating Nodal Data

Nodal data necessary to formulate a well-posed zoning statement isgenerated by Midnode by first providing lists of candidate nodes for theentire domain including a part list 60 and a void space list 61 and thenrefining those lists to create the list of part nodes 60 and a list ofvoid space nodes 61 shown previously in FIGS. 4 b and 4 c. There are avariety of ways including mesh-related methods and random nodegeneration for generating the list of candidate nodes and then theindividual lists.

Node Generation from Mesh

Techniques for generating nodal data from a mesh include elementvertices, element centroids, mid-side nodes, toleranced offset nodes andedge tracing. The mesh information provides not only the location ofcorner nodes but also how to make up a solid element from a set ofcorner nodes. The computer can trace a line from one node to another andknow that only the material portion of the domain is being traversed(with some caveats). For the purposes of this exemplary process, it isassumed that a mesh such as shown in FIGS. 4 b and 4 b has been renderedusing a commercial meshing tool, and that the data available followingthe use of that tool is at least, but not limited to nodal coordinatesof each vertex of each element (or control volume in the case of afinite difference mesh) and a reference to the nodes that comprise eachelement. Each method is outlined below.

Element Vertices

The vertices of each element can be used as nodes directly. However, thevertices are frequently coincident with bounding surfaces and hence area poor choice when seeking to test which side of a surface material thenode happens to reside on. In practice, inaccuracy in mesh generationoften will lead to the generation of vertices very close to, but on theincorrect side of, the surface it is supposed to be coincident with.This problem may be abated by establishing a tolerance value, measuringthe distance between each vertex and every surface, and discarding anypoint that happens to be closer to any surface than the tolerance value.This approach has been demonstrated to work in practice. However, thinregions of material that happen to be meshed by only one layer ofelements frequently elude this method since all such vertices may bediscarded. This difficulty led to the use of centroid and mid-side nodesas additional nodes.

Element Centroids

Determining the element centroid by computing the average value of eachof the coordinates of the vertices is one way to get nodal data that istypically not coincident with a surface and may be located in a thinregion. However, in the case of an element that describes a regionoutside and adjacent to a concave surface the centroid of a thin elementcan end up inside the concavity. This conflict can be prevented byascertaining whether three vertices of an element are located on asingle surface, and discarding the centroid of such an element.

Mid-side Nodes

Another method for locating nodes in thin regions is to calculate themean coordinate locations of each pair of adjacent vertices to form amid-node. This method generates far more nodes than the centroidapproach, and thus results in a more comprehensive representation of thegeometry. A test is performed to determine whether a pair vertices bothlie on a common surface; such points are discarded.

Toleranced Offset Nodes

Even using centroids and mid-edge nodes, some regions may not becaptured by the nodal data. In this case, the addition of nodes on eachelement edge located a distance slightly larger than the tolerancedistance (mentioned above) away from each vertex that defines the edgehas proven effective to capture these regions.

Edge Tracing

In highly complex geometries the node density achieved using theprevious four methods may not be sufficient to characterize the part. Inthese cases the generation of additional nodes by tracing along eachedge of each element, counting the number of surface crossingsencountered, and generating an additional node for each one has proveneffective to characterize the part.

Edge Tracing has been implemented in an exemplary algorithm by comparingthe element vertices at either end of an edge, in turn, to each surfacein the geometry, determining which side of the surface the vertex is on.Then the number of surface crossings is computed by differencing thenodal zoning statements generated in the previous two operations.Finally, the edge is successively bisected with respect to one vertexuntil only one surface crossing is computed, and that location is usedto generate a node. This process is recursively employed to generate anode corresponding to each surface crossing. Occasionally a concavesurface can be crossed twice by the edge of a coarse mesh element. Inthis circumstance discarding any prospective node that lies on theopposite side of any surface with respect to both vertices has beeneffective.

Random Node Generation

Some CAD or geometrical modeling implementations support the ability todetermine whether a given coordinate location is in material or thespace surrounding or internal to the material region. If the part ofinterest exists in such a context, it is not necessary to formally meshthe part; merely generating a sufficiently dense distribution of randomnodes over a domain somewhat larger than the part will provide thenecessary data. Using the meshing approach, it is necessary toseparately mesh the material of the part, and the void space within andaround the part; correspondingly, as random nodes are generated theyneed to be sorted into two groups: void nodes and material nodes. As inthe case of meshing, it is prudent to discard any random nodes whichhappen to be generated within a tolerance distance of any surface, inorder to avoid ambiguity due to inaccuracies that may develop during thepointwise interrogation of the model. A uniform distribution in eachcoordinate direction will generate a suitable array of test points, butif data exists as to the complexity of various regions of the model,some benefit can be realized by increasing the number density of testpoints generated in those locales.

Formulating a Zoning Statement

Once complete lists of the analytic surfaces 62 and the nodal data 60and 61 for the part are available, the computer-implemented process canformulate a well-posed zoning statement. Essentially, the algorithmcompiles an ordered binary list for each node that states therelationship between the node and each of the surfaces from the surfacelist. Each of these lists is referred to herein as a “nodal zoningstatement.” Recall that analytic surfaces divide space into two regions,the “interior” and “exterior” regions. The binary list identifies thecorresponding node as lying “inside” or “outside”, e.g. to left orright, above or below, each surface on the list using a series of “true”and “false” statements, or “1” and “0” in binary terms. As eachsuccessive node is treated, it is compared to all previously calculatedbinary lists for earlier nodes. If the list already exists, the node isignored. If not, the binary list for that node is appended to a listcomprising all previous unique nodes; the table of lists is a well-posedzoning statement for the part.

As shown in FIG. 8 a, the computer-implemented Midnode algorithm is anested loop structure in which each node 279 in FIG. 8 b is selected inturn and compared to every surface from the surface list beforeproceeding to the subsequent node. More specifically, the first node onthe list is selected (step 280) and the first surface on the list isselected (step 282). The distance from the node to the surface iscomputed (step 284) in order to determine if the distance is less than apre-defined tolerance value (suitably 1×10⁻⁵, distance units) (step286). If true, the node is discarded in order to avoid any potentialinaccuracy that would result in a miscalculation of which side of thatsurface the point was actually meant to reside on. The algorithm checksto determine whether any more nodes are on the list (step 288) and, ifyes, increments the node (step 290) and repeats the loop. If the node isnot too close to the surface, the algorithm computes the “surface sense”with respect to the node (step 292). Since every analytic surfacedivides all of space into two regions, we arbitrarily construe one ofthese sub-regions of space to constitute the “inside” of the surface,and the other the “outside”. The algorithm determines whether the nodeis “inside” the surface (step 294) and either appends a “true” to thenodal zoning statement (step 296) or a “false” (step 298). If there areany more surfaces on the list (step 300), the algorithm increments thesurface (step 302) and computes the distance (step 284). Using theknowledge of the position of a node with regard to every surface in themodel, a nodal zoning statement 67 is constructed, this is a single rowtruth table, ordered by surface number, with a “true” (“+”) (“1”) entrycorresponding to every surface the node is “inside”, and a “false” (“−”)(“0”) entry for each surface the node is “outside” as shown in FIG. 8 c.

When a nodal zoning statement 67 has been successfully completed for anode, that zoning statement is compared to the previously computedzoning statements for all previous nodes (step 304). If the newlycomputed zoning statement is truly novel, it is appended to the list ofunique nodal zoning statements (step 306). When all nodes have beenprocessed in this fashion, the complete list of unique nodal zoningstatements can be said to constitute a complete zoning statement 68 forthe part (step 308). As shown in FIG. 8 b, each node that lies farenough away from a surface is labeled as M1, M2, . . . M6. Nodes thathave the same nodal zoning statement are denoted in this figure ashaving the same label.

Once the truth tables (zoning statements) T for the part and F for anyvoid spaces have been computed, it is also frequently helpful (thoughnot necessary for this process) to pre-compute the truth table entrieswhich are absolutely necessary in order for the solution to bewell-posed (step 309). This is done by creating a mandatory table M inwhich all the entries are initially false. The rows of the materialtruth table T are compared one-by-one to each row of the void truthtable F. If ever a pair of such rows is found to differ by only oneentry, it is certain that that entry must always be maintained in anytrial solution for the solution to be well-posed. Accordingly, thatentry in the M table is set to true. If ever such an entry were deleted,there would be nothing to distinguish a portion of the material fromsome portion of the void, hence the two must overlap, which is notphysically possible.

It is possible to use the zoning statement produced by the Midnodealgorithm to construct a combinatorial geometry statement of the part,however, in practice it has been found that an optimized zoningstatement for a part can typically provide two orders of magnitudeimprovement in runtime when performing radiation transport analysis.Therefore, the final step of this process suggests the use of anoptimization routine on the part's zoning statement (step 310).

Optimizing Zoning Statement

Optimization entails eliminating references to redundant surfaces andmerging zones in the statement and is accomplished by operating on thetruth table (the base zoning statement 68 shown in FIG. 8 c) thatrelates the position of all the nodes on both the part and void spacelists to the analytic surfaces (both boundary and ambiguity surfaces)that comprise the entity. The optimization process, being a specialformulation of the general binary minimization problem, may take anynumber of forms, but the current best practice is a comprehensive way ofiteratively subdividing the domain of the part (e.g. the“positive-valued” truth table), solving each of the sufficiently smallpieces independently using a genetic algorithm, regressing back throughthe decomposition process and repeating the solution procedure with eachreunited subdomain until the entire geometry has been reunited. A fulldiscussion of this algorithm is provided in co-pending U.S. patentapplication entitled “Method for Solving the Binary Minimization Problemand a Variant Thereof”, filed on ______, 2004, which is herebyincorporated by reference.

More specifically, a “Break” routine iteratively bisects the domains(truth table) into smaller and smaller sub-domains (sub-tables). A“Zoner” routine operates on the lowest level sub-tables, computingoptimized zoning statements for each. A “Rebuild” routine iterativelyrecombines bisected sub-tables starting at the lowest level and workingbackwards. Using the zoning statements from the lower level sub-tables,Rebuild further refines the zoning at the next higher level. Whencomplete, Rebuild produces a single truth table representing theoptimized zoning statement for the entire problem. This procedure notonly out-performs the generic solution procedure as applied to the wholegeometry (simultaneously) in terms of the solution time, it typicallyarrives at a more optimal solution as well. This process has an addedadvantage of providing a working solution at every uniting iterationfollowing the solution of all the smallest subdomains. Thus for anygeometries that are so complicated that the final uniting steps are tootime-consuming to bother with, a working solution can be gleaned fromthe output at any intervening time.

Break

At the beginning of the bisection process it is expected that a completeset of input data will be supplied by the translation algorithm. Thisinput data should include at least two truth tables: the firstrepresents the explicit known input set that results in [true] valuedoutput, the second represents the explicit known input set that resultsin [false] valued output. In geometrical terms, these can be construedas the material and void truth tables, respectively. These tables arenot required to be complete; that is, together they do not have torepresent every possible Boolean combination of the columnar inputvalues. At least in the case of the geometrical formulation, certaincombinations of inputs will not be possible; therefore it would limitthe framework of this solution procedure to require exhaustivelycomplete tables. The input may also include the mandatory truth tables.These mandatory entries can also be provided to the bisection procedure,which can reformulate them as the problem is bisected, and pass therequired information down and back up the tree as the algorithmproceeds.

The input may also include any a priori ranking of columns (surfaces)for selection as bisectors. Logical bisection candidates may becalculated as the algorithm proceeds, so there is no requirement forthese to be available in the input. The bisecting column may be selectedusing Node Weighted Surface Selection, Area Weighted Surface Selection,Surface Selection by Type or Surface Selection by Parameter. The mostrobust implementation will use several of these criteria simultaneously.This will allow the most optimal surfaces to be chosen early in theprocess, which has been demonstrated to lead to highly optimizedsolutions in a minimum of computation time.

Node Weighted Surface Selection

When the truth table data has been constructed using a finite elementdiscretization of the original geometry, a sizable fraction of nodepoints will lie on the bounding surfaces of the geometry. The surfacesthat are the most populated with nodes are selected as the bisectioncolumn.

Area Weighted Surface Selection

In a geometry formulation where a finite element discretization is notavailable or is too expensive to calculate, the area of each boundedexternal surface of the part may be computed. Attractive bisectionsurfaces are those that bound large external surface areas.

Surface Selection by Surface Type

Frequently the unbounded surfaces that make up a geometrical part are ofmany different types, e.g. sphere, cylinder, plane. A priori knowledgeof the part's geometry can determine which types of surfaces will makegood bisection surfaces.

Surface Selection by Surface Parameter

A parameter or a set of parameters can be used to differentiate betweengood candidates and bad. Use of the radius or the angular alignment of asurface entity are particularly valuable parameters on which to baseselection of bisection surfaces.

The bisection process starts by selecting a truth table T for the part,its complement F for the void space(s), the associated mandatory table Mand a bisection column. The computer then produces sub-tables for the Ttable for the bisection column and their complements. The M table issplit into sub-tables to correspond to the division of the truesub-tables. Finally, the computer simplifies the T sub-tables, thecomplements and the M sub-tables. All of the sub-tables are stored andthe process repeated recursively for each T sub-table until they aresufficiently small.

A flowchart and graphic representation of the bisection process areshown in FIGS. 9 a and 9 b. The process is initiated by determiningwhether there are any remaining truth tables with more than a thresholdnumber of rows (step 320). The threshold can be set arbitrarily, but asuitable value of 15 has been chosen by trial and error. If there areany such tables, the process selects a truth table T 321 and itscomplement F (step 322) and selects a bisecting column for truth table T(step 324).

Once the bisecting column has been chosen, splitting the larger truthtable in two is performed simply by building two new smaller sub-tables323, 325, one is a copy of each of the rows from the original table thathas [true] as the entry for the chosen column, TA (step 326). The othersub-table gets copies of all of the rows that read [false] in the chosencolumn, TB (step 328). This operation is performed on the [true] valuedtruth table. Additionally, the array of mandatory entries, M (which hasrows and columns corresponding one-for-one with the [true] truth table)can be split up into two pieces as well, each row is assigned to asub-table corresponding to either the [true], MA, or [false], MB, sideof the bisecting column, depending on whether the corresponding row ofthe truth table had a [true] or [false] value in that column (step 329).Two copies are made of the [false] valued truth table (FA, FB) (steps330, 332) and one copy is assigned to each half of the [true] valuedtruth table. Next, additional information is appended to each of the twonew copies (steps 334, 336); each sub-table has the rows of the oppositehalf of the [true] valued truth table appended to it (FA=F+TB; FB=F+TA).This ensures, as the solution proceeds, that the two lower levelsolutions will not overlap under any condition.

At every step of the bisection routine, copies of the truth sub-tablesare stored for later use during reconstitution. In the exemplaryoptimization routine the truth sub-tables are simplified at each step(steps 342, 344) by eliminating identical rows, eliminating any columnsthat are not necessary to represent the part and finally eliminating anyidentical rows created by culling the columns. At every step an orderedlist of the columns and rows (referenced to the original truth tables)which persist in the sub-table at that point in the process is stored.In addition, some sort of invertible path structure is stored as therecursive bisection takes place, so that a map can be constructed whichwill allow the appropriate pairs of files to be reunited in theappropriate order leading all the way back to the original truth tableconstruct.

Finally when the bisection process has been repeated recursively to thepoint where all remaining [true] valued truth sub-tables are smallerthan some threshold, i.e. step 320 is false, the desired optimizationroutine (“Zoner”) can applied at this lowest level. Because these lowlevel optimizations are independent of one another they may beimplemented as parallel processes if desired. In the exemplaryimplementation of this invention a binary minimization algorithmincorporating a genetic algorithm is used to optimize the truth tables,but any optimization routine may be successfully used in this process.

Zoner

The binary minimization algorithm embodied in “Zoner” solves the problemof representing each sub-table, which represents a sub-domain of thepart, as a simplified trinary zoning statement with the fewest zones andanalytic surfaces required to isolate the part from the void space. Inthe current embodiment this is accomplished for each truth sub-table byforming a seed organism using a trinary representation, creating a poolof initial organisms from the seed, breeding the pool until thepopulation stabilizes and then selecting the highest scoring trinaryzoning statement. The proven theory is that the children of the parentswill be better organisms and score higher. This genetic algorithm willconverge to the optimized zoning statement much faster than a random orexhaustive search.

As shown in FIG. 9 c, “Zoner” opens truth table files (step 350), readsin and stores the truth sub-table files (step 352) and then enters aloop which will create an initial population of organisms, beginningwith one formed directly from the material truth table (step 354). Theseed organism is formed by mapping each T table entry to a “1” and eachfalse table entry to a “−1”. An initial pool of organisms is created byduplicating the seed and changing some of the +1, −1 values to 0s. Thiscan be done randomly, all but mandatory entries in a given row, or fordifferent entries in adjacent rows. As the pool of organisms totaling,for example, one tenth the size of the entire eventual population isformed, each organism is scored on the fly (step 356). If an organismwould permit an entry from the F table (e.g. identify a point in voidspace as the part) it is assigned a score of zero. Otherwise the scoreis inversely proportion to the product of the number of unique rows inthe organism and the number of non-zero entries in those unique rows.Thus, an organism that has few rows and many zeros without admitting afalse entry has a very high score. Any organism that fails to meet athreshold score (step 358) is not saved, and a replacement isimmediately generated (step 360).

When a sufficient quantity of organisms has been created and saved(steps 362, 364), the organisms are sorted (using, for example, thecommon sort routine, Heapsort) by score (step 366). In later passesthrough the loop, the bottom 90% of the organisms are destroyed (step368), but the first time through the loop, only 10% of the overall poolhas been created, so no organisms are destroyed. The pool is then filledout by the breeding procedures (step 368) such as asexual binaryreproduction with various mutation techniques. At this point thealgorithm commences its main task: scoring (step 370), ranking (step372), killing (step 374) and breeding (step 368) repeatedly, until thepopulation demonstrates stability (step 376). “Population stability” isdefined as a combination of the lack of variation in the score of thesurvivors, and the repetition of the same top score in severalsuccessive generations. Stability is guaranteed to be achieved with asuccessful result, however, if the threshold was set too large it may ormay not be the case that the result encountered is reasonablyapproaching the optimal solution. Once stabilized, Zoner writes the zonedefinitions to an output file (step 378) and determines whether thereare more files to zone (step 380).

Rebuild

Solutions to each miniature optimization problem can be stated in atruth-table analog format that serves to simplify the bookkeeping whentwo sub-tables are reunited. In this form, the row-column format ispreserved with one-to-one correspondence, but the entries in the tableare trinary data corresponding to [true], [n/a], and [false], e.g.(1,0,−1) respectively. In order to preserve the number of rows in anoptimized solution, multiple copies of any term that comprises asolution for more than one row are made in the solution table. Thisdoesn't mean that the solution actually contains as many terms as thereare rows in the truth table, as any duplicate solution rows actually arerepresentative of only a single solution term.

Reuniting two lower level sub-tables is not necessary if intermediatetables are stored during the bisection process. Each of these higherlevel sub-tables is a fresh problem statement in it own right, but usingthe two solution tables for the lower level sub-tables will yield asolution for the higher level problem, but it is now possible to furtheroptimize the solution at the higher level. The solution tables arecombined by interleaving the solution rows into their appropriatepositions (recalling that the higher level truth table was broken in twoby dividing rows into two groups, and that each solution row correspondsdirectly to a lower level truth table row) and filling any missingcolumns with the [n/a] trinary correlate (0). Using this new solutiontable as a starting point, optimization is typically greatly simplified,frequently by orders of magnitude in computation time.

The solution and solution reunification procedure is applied tosuccessively higher levels of sub-tables, replicating the bisectionprocedure in reverse. For very complicated problems it may occur that asthe sub-tables get increasingly large the payoff in terms ofoptimization isn't worth the increased solution time. This solutionprocedure is quite amenable to premature termination, as anyintermediate solution is an effective solution (and often a highlyoptimized solution) of the overall problem. It is only necessary in thiscase to combine all of the highest level solution tables according tothe above procedure, and an effective solution can be established. Thereunification and higher level solution process is also independent frompair to pair, so it is also quite simple to implement as a parallelalgorithm if desired.

The exemplary algorithm that implements the above logic is presented inFIG. 9 d. In this procedure, the loop structure begins with a tree ofsub-tables produced by iterative bisection and simplification, whereonly the lowest levels of each branch have been solved. The procedureterminates when all the sub-tables have been collected by binaryrecombination, and an overall solution has been calculated (step 382).With each pass through the loop, a pair of complementary sub-tables (Tand F) from the lowest remaining unsolved level is chosen (step 384). Ithas been found that as the size of T increases, the length of time ittakes to compute new solutions increases dramatically. Furthermore, ithas been found that the likelihood of substantive improvements in thesolution decreases with the size of T when lower level solutions areprovided. Therefore, the current implementation decreases the tolerancevalue for solution stability as T increases, so that inordinate amountsof time aren't spent when improvements are unlikely and costly tocompute (step 386).

The solution procedure begins by identifying the two lower levelsolution tables (from the solutions for TA and TB) and extracting thegenetic information from those solutions, reformulating it to meet therequirements of the higher level sub-table by adding zeros within eachrow corresponding to any eliminated columns, and interleaving the rowsof the solutions to match T (step 388). The genes of this tentativesolution are used to create an organism to seed the population of thegenetic organisms representing the solution for T (step 390). Next, theZoner algorithm is used in concert with the pre-determined tolerancevalue and the trial solutions to genetically improve the proposedsolution (step 392). When the tolerance value is achieved, the solutionis stored (step 394), and the lower level truth tables are deleted orflagged as solved (step 396). When the solution is complete for T, theloop continues by identifying the subsequent lowest level unsolvedsub-table.

EXAMPLE ProE CAD Model to TART Format

The exemplary process of FIG. 10 is one instantiation of a completetranslation scheme to produce combinatorial geometry in TART format fromProE CAD part data. The first step is to extract from ProE (step 400)the IGES file (Part.igs) 402 representing the part geometry. This dataincludes the trimmed bounding surface data for the part. TheProMechanica package of ProE can be used to discretize the part and thespace around the part (step 404). These two meshes are stored in ANSYSformat as Part.ans 406 and Part-.ans 408 respectively.

The next step is to run the IGESread routine (step 410). This accepts asinput the IGES file part.igs, and produces as output the boundarysurface primitives for the part in file part.sur 412. The Ambisurfroutine is executed (414) to compute the candidate ambiguity surfaceprimitives. The output file Part.zsr 416 is a combined listing ofboundary and ambiguity surface primitives.

The Midnode routine transforms the problem from one of geometry to onestated strictly in terms of logic (step 418). Each node in the part.ansfile is compared to each surface in the Part.zsr file, and a truth tablerow is constructed that represents the position of the node (in a binarysense) with respect to all the surfaces; recall that each boundingsurface divides all of space into a positive region (true), and anegative region (false). The truth table merely collects the truth rowinformation for each mesh point. Midnode also computes additional pointsfrom the mesh data, and collects them in the truth table as well. Thisprocess is repeated with the mesh in part-.ans for the void space aroundand internal to the part. Next, midnode simplifies the truth tables byeliminating duplicate rows and surfaces that are not absolutelynecessary to differentiate material region from void regions. Thesesimplified truth tables are stored in part.nod 420 and part-.nod 422.Finally, Midnode writes files with additional data: part.snx 424 liststhe ordered surface indices from part.sur which are used in thesimplified truth tables, part.mst 426 is a material truth table analogwhich shows which truth table entries can be precomputed to be necessaryto differentiate part from void, part.nzf 428 is created to carryinformation about how many part.nod files there are (at this point thatnumber is the default, 1), and part.rec 430 contains information aboutwhich surfaces are good candidates for the bisection operation.

The Break routine performs iterative bisection of the problem (step432), simplifying truth tables and generating two sets of part nod 434,part-.nod 436, part.mst 438 and part.snx 440 files at each step. As thebisection proceeds, a part.bbd file 442 is continually updated to keeptrack of the bisection tree throughout the process. Also, the part.nzffile is continually updated with the total number of files generated forbookkeeping.

The Zoner code operates on all of the lowest level members of the filetree, computing minimized zoning statements (in trinary logic) for each(step 444). These are the part.gen.# files 446. Additionally, a part.zodfile 448 is generated and updated at each iteration, which includesinformation concerning which files represent lowest level members of thefile tree.

Next, the Rebuild routine iteratively recombines bisected truth tablesstarting at the lowest level and working backwards (step 450). Using thezoning statements from the lower level entities, Rebuild further refinesthe zoning at the next higher level. When complete, Rebuild produces asingle Part.gen file 452 representing the computed minimized zoningstatement for the entire problem.

The last step in the exemplary procedure from FIG. 10 is the routineMake TART, which reintroduces the geometric representation of theproblem, combining the surface primitive information (part.zsr) with thecomputed zoning statement (part.gen) to form a working input deckPart.tart.in file 454 for the TART code (456).

While several illustrative embodiments of the invention have been shownand described, numerous variations and alternate embodiments will occurto those skilled in the art. Such variations and alternate embodimentsarc contemplated, and can be made without departing from the spirit andscope of the invention as defined in the appended claims.

1. A method for translating high order complex geometry from a computer aided design (CAD) model to a surface based combinatorial geometry format, comprising: Writing a list of trimmed surfaces from the CAD model, said trimmed surfaces being a bounded representation of a geometric surface in space; Generating lists of nodes that lie within the part or within any void spaces represented in the CAD model; Translating the trimmed surfaces into a list of analytic surfaces including bounding surfaces and ambiguity surfaces; and Formulating a well-posed zoning statement from the list of analytic surfaces and the list of nodes.
 2. The method of claim 1, wherein the lists of nodes are generated by, Writing two lists of candidate nodes that cover the part and the void spaces, and Refining these lists of nodes such that the first one consists of only nodes that lie within the part but away from any of the analytic surfaces and the second one consists of only nodes that lie within the void spaces but away from any of the analytic surfaces.
 3. The method of claim 2, wherein the lists of candidate nodes are written using a mesh or random node generation.
 4. The method of claim 3, wherein a finite element (FE) program generates the mesh.
 5. The method of claim 1, wherein the translation and formulation comprise: Calculating analytic bounding surfaces from the trimmed surfaces to provide the bounding surfaces; Forming the ambiguity surfaces required for a well-posed zoning statement by comparing the bounding surfaces to each other; and Comparing each node to each of the analytic surfaces to create a sequence of nodal zoning statements, said unique nodal zoning statements together forming the well-posed zoning statement.
 6. The method of claim 5, wherein the list of trimmed surfaces includes a number of entities, a type designator for each entity and a translation matrix, said extraction of untrimmed spatial primitives comprising: Examining each entity to determine a type of geometric object; and Mapping the entity to the analytic bounding surface for the geometric object with the proper translation.
 7. The method of claim 6, wherein the analytic forms for b-spline planes, toroids, spheres, revolved planes, cylinders or revolved cone objects are extracted from the information regarding trimmed surfaces.
 8. The method of claim 5, wherein forming the ambiguity surfaces comprises: Performing a pair-wise comparison of all the bounding surfaces; Determining whether a condition exists between each pair of bounding surfaces; and, if so, Generating a specific analytical ambiguity surface to differentiate regions of space that the bounding surfaces may be insufficient to distinguish.
 9. The method of claim 8, wherein the ambiguity surfaces are generated using a library that contains a plurality of pair-wise comparisons, the associated conditions and the formulae for the ambiguity surfaces.
 10. The method of claim 5, wherein each nodal zoning statement comprises a string of signed numbers that designate the binary positional relationship to each of the analytic surfaces. 